home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2004 #2 / Amiga Plus CD - 2004 - No. 02.iso / AmiSoft / Dev / cross / Annotate.lha / annotate / source / annotate.c next >
Encoding:
C/C++ Source or Header  |  2003-12-23  |  43.4 KB  |  1,392 lines
  1. #include <exec/types.h>
  2. #include <exec/memory.h>
  3. #include <exec/execbase.h>
  4. #include <dos/dos.h>
  5. #include <stdlib.h>
  6.  
  7. typedef signed char    FLAG;   /* 8-bit signed quantity (replaces BOOL) */
  8. typedef signed char    SBYTE;  /* 8-bit signed quantity (replaces Amiga BYTE) */
  9. typedef signed short   SWORD;  /* 16-bit signed quantity (replaces Amiga WORD) */
  10. typedef signed long    SLONG;  /* 32-bit signed quantity (same as LONG) */
  11. #define elif           else if
  12. #define AGLOBAL        ;       /* global (project-scope) */
  13. #define MODULE         static  /* external static (file-scope) */
  14. #define PERSIST        static  /* internal static (function-scope) */
  15. #define AUTO           auto    /* automatic (function-scope) */
  16.  
  17. #define TAB             9
  18. #define LF             10
  19. #define CR             13
  20.  
  21. #define MEMMAPLINES 17
  22. MODULE struct
  23. {   ULONG  address;
  24.     STRPTR description;
  25. } memmap[MEMMAPLINES] =
  26. { { 0x0000, "ROM"                     },
  27.   { 0x1000, "unmapped"                },
  28.   { 0x1800, "upper screen"            },
  29.   { 0x18D0, "user RAM"                }, 
  30.   { 0x18F0, "hardware registers"      }, 
  31.   { 0x18F8, "user RAM"                }, 
  32.   { 0x18FC, "hardware registers"      }, 
  33.   { 0x1909, "unmapped"                }, 
  34.   { 0x1980, "hardware registers"      }, 
  35.   { 0x19C0, "unmapped"                }, 
  36.   { 0x19F8, "hardware registers"      }, 
  37.   { 0x1A00, "lower screen or user RAM"}, 
  38.   { 0x1AD0, "user RAM"                }, 
  39.   { 0x1B00, "unmapped"                }, 
  40.   { 0x2000, "ROM"                     },
  41.   { 0x8000, "modulo (>32K) access"    },
  42.   {0x10000, NULL                      }
  43. };
  44.  
  45. #define EQUATESLINES 135
  46. MODULE STRPTR equates[EQUATESLINES] =
  47. {
  48. ";Hardware Equates/Memory Map----------------------------------------------",
  49. ";                   $0000..$0FFF: ROM (first 4K of cartridge)",
  50. ";                   $1000..$17FF: unmapped",
  51. ";                   $1800..$18CF: upper screen",
  52. ";                   $18D0..$18EF: user RAM",
  53. "SPRITE0Y        equ $18F0",
  54. "SPRITE0X        equ $18F1",
  55. "SPRITE1Y        equ $18F2",
  56. "SPRITE1X        equ $18F3",
  57. "SPRITE2Y        equ $18F4",
  58. "SPRITE2X        equ $18F5",
  59. "SPRITE3Y        equ $18F6",
  60. "SPRITE3X        equ $18F7",
  61. ";                   $18F8..$18FB: user RAM",
  62. "CRTCVPR         equ $18FC        ;crtc vertical position register",
  63. "PITCH           equ $18FD        ;also other uses",
  64. ";    bit  7:                      0 = normal mode",
  65. ";                                 1 = alternate character mode colour 2x2",
  66. ";    bits 6..0:                   pitch",
  67. "VOLUME          equ $18FE        ;also other uses",
  68. ";    bits 7..5:                   horizontal scanline scrolling (0..7)",
  69. ";    bit  4:                      noise on/off",
  70. ";    bit  3:                      tones on/off",
  71. ";    bits 2..0:                   volume (0..7)",
  72. "CHARLINE        equ $18FF        ;current character line",
  73. "P1LEFTKEYS      equ $1900",
  74. ";    bits 7..4:                   unknown",
  75. ";    bit  3:                      p1 (left) '1' button",
  76. ";    bit  2:                      p1 (left) '4' button",
  77. ";    bit  1:                      p1 (left) '7' button",
  78. ";    bit  0:                      p1 (left) 'E' button (Enter)",
  79. "P1MIDDLEKEYS    equ $1901",
  80. ";    bits 7..4:                   unknown",
  81. ";    bit  3:                      p1 (left) '2' button",
  82. ";    bit  2:                      p1 (left) '5' button",
  83. ";    bit  1:                      p1 (left) '8' button",
  84. ";    bit  0:                      p1 (left) '0' button",
  85. "P1RIGHTKEYS     equ $1902",
  86. ";    bits 7..4:                   unknown",
  87. ";    bit  3:                      p1 (left) '3' button",
  88. ";    bit  2:                      p1 (left) '6' button",
  89. ";    bit  1:                      p1 (left) '9' button",
  90. ";    bit  0:                      p1 (left) 'C' button (Clear)",
  91. "P1PALLADIUM     equ $1903",
  92. ";    bits 7..4:                   unknown",
  93. ";    bit  3:                      p1 (right) Palladium button #1",
  94. ";    bit  2:                      p1 (right) Palladium button #2",
  95. ";    bit  1:                      p1 (right) Palladium button #3",
  96. ";    bit  0:                      p1 (right) Palladium button #4",
  97. "P2LEFTKEYS      equ $1904",
  98. ";    bits 7..4:                   unknown",
  99. ";    bit  3:                      p2 (right) '1' button",
  100. ";    bit  2:                      p2 (right) '4' button",
  101. ";    bit  1:                      p2 (right) '7' button",
  102. ";    bit  0:                      p2 (right) 'E' button (Enter)",
  103. "P2MIDDLEKEYS    equ $1905",
  104. ";    bits 7..4:                   unknown",
  105. ";    bit  3:                      p2 (right) '2' button",
  106. ";    bit  2:                      p2 (right) '5' button",
  107. ";    bit  1:                      p2 (right) '8' button",
  108. ";    bit  0:                      p2 (right) '0' button",
  109. "P2RIGHTKEYS     equ $1906",
  110. ";    bits 7..4:                   unknown",
  111. ";    bit  3:                      p2 (right) '3' button",
  112. ";    bit  2:                      p2 (right) '6' button",
  113. ";    bit  1:                      p2 (right) '9' button",
  114. ";    bit  0:                      p2 (right) 'C' button (Clear)",
  115. "P2PALLADIUM     equ $1907",
  116. ";    bits 7..4:                   unknown",
  117. ";    bit  3:                      p2 (right) Palladium button #1",
  118. ";    bit  2:                      p2 (right) Palladium button #2",
  119. ";    bit  1:                      p2 (right) Palladium button #3",
  120. ";    bit  0:                      p2 (right) Palladium button #4",
  121. "CONSOLE         equ $1908",
  122. ";    bits 7..3:                   unknown",
  123. ";    bit  2:                      DIFFICULTY button",
  124. ";    bit  1:                      OPTION button",
  125. ";    bit  0:                      START button",
  126. ";                   $1909..$197F: unmapped",
  127. ";                   $1980..$1987: sprite #0",
  128. ";                   $1988..$198F: sprite #1",
  129. ";                   $1990..$1997: sprite #2",
  130. ";                   $1998..$199F: sprite #3",
  131. "UDC0            equ $19A0",
  132. ";                   $19A0..$19A7: user-defined character #0",
  133. "UDC1            equ $19A8",
  134. ";                   $19A8..$19AF: user-defined character #1",
  135. "UDC2            equ $19B0",
  136. ";                   $19B0..$19B7: user-defined character #2",
  137. "UDC3            equ $19B8",
  138. ";                   $19B8..$19BF: user-defined character #3",
  139. ";                   $19C0..$19F7: unmapped",
  140. "RESOLUTION      equ $19F8",
  141. ";    bit  7:                      0 = normal mode",
  142. ";                                 1 = block graphics mode",
  143. ";    bit  6:                      0 = low-res mode",
  144. ";                                 1 = high-res mode",
  145. ";    bits 5..0:                   rectangle descriptions in block graphics mode",
  146. "BGCOLOUR        equ $19F9",
  147. ";    bit  7:                      0 = low-res mode",
  148. ";                                 1 = high-res mode",
  149. ";    bit  6:                      paddle interpolation (switches between axes of analog sticks)",
  150. ";    bits 5..3:                   colours of tile set 0",
  151. ";    bits 2..0:                   background colour",
  152. "SPRITES23CTRL   equ $19FA",
  153. ";    bit  7:                      0 = sprite #2 double-height",
  154. ";                                 1 = sprite #2 normal",
  155. ";    bit  6:                      0 = sprite #3 double-height",
  156. ";                                 1 = sprite #3 normal",
  157. ";    bits 5..3:                   colours of sprite #2",
  158. ";    bits 2..0:                   colours of sprite #3",
  159. "SPRITES01CTRL   equ $19FB",
  160. ";    bit  7:                      0 = sprite #0 double-height",
  161. ";                                 1 = sprite #0 normal",
  162. ";    bit  6:                      0 = sprite #1 double-height",
  163. ";                                 1 = sprite #1 normal",
  164. ";    bits 5..3:                   colours of sprite #0",
  165. ";    bits 2..0:                   colours of sprite #2",
  166. "BGCOLLIDE       equ $19FC",
  167. ";    bits 7..4:                   unknown",
  168. ";    bits 3..0:                   collision between sprites #3..#0 (respectively) and background",
  169. "SPRITECOLLIDE   equ $19FD",
  170. ";    bits 7..6:                   unknown",
  171. ";    bit 5:                       sprites #2/#3 collision",
  172. ";    bit 4:                       sprites #1/#3 collision",
  173. ";    bit 3:                       sprites #1/#2 collision",
  174. ";    bit 2:                       sprites #0/#3 collision",
  175. ";    bit 1:                       sprites #0/#3 collision",
  176. ";    bit 0:                       sprites #0/#3 collision",
  177. "P2PADDLE        equ $19FE",
  178. "P1PADDLE        equ $19FF",
  179. ";                   $1A00..$1ACF: lower screen",
  180. ";                   $1AD0..$1AFF: user RAM",
  181. ";                   $1B00..$1FFF: unmapped",
  182. ";                   $2000..$7FFF: ROM (last 24K of cartridge)"
  183. };
  184.  
  185. #define REPLACEMENTS 33
  186. MODULE struct
  187. {   STRPTR old, new;
  188. } replacement[REPLACEMENTS] =
  189. { {"8F0", "SPRITE0Y"     }, 
  190.   {"8F1", "SPRITE0X"     },
  191.   {"8F2", "SPRITE1Y"     },
  192.   {"8F3", "SPRITE1X"     },
  193.   {"8F4", "SPRITE2Y"     },
  194.   {"8F5", "SPRITE2X"     },
  195.   {"8F6", "SPRITE3Y"     },
  196.   {"8F7", "SPRITE3X"     },
  197.   {"8FC", "CRTCVPR"      },
  198.   {"8FD", "PITCH"        },
  199.   {"8FE", "VOLUME"       },
  200.   {"8FF", "CHARLINE"     },
  201.   {"900", "P1LEFTKEYS"   },
  202.   {"901", "P1MIDDLEKEYS" },
  203.   {"902", "P1RIGHTKEYS"  },
  204.   {"903", "P1PALLADIUM"  },
  205.   {"904", "P2LEFTKEYS"   },
  206.   {"905", "P2MIDDLEKEYS" },
  207.   {"906", "P2RIGHTKEYS"  },
  208.   {"907", "P2PALLADIUM"  },
  209.   {"908", "CONSOLE"      },
  210.   {"9A0", "UDC0"         },
  211.   {"9A8", "UDC1"         },
  212.   {"9B0", "UDC2"         },
  213.   {"9B8", "UDC3"         },
  214.   {"9F8", "RESOLUTION"   },
  215.   {"9F9", "BGCOLOUR"     },
  216.   {"9FA", "SPRITES23CTRL"},
  217.   {"9FB", "SPRITES01CTRL"},
  218.   {"9FC", "BGCOLLIDE"    },
  219.   {"9FD", "SPRITECOLLIDE"},
  220.   {"9FE", "P2PADDLE"     },
  221.   {"9FF", "P1PADDLE"     }
  222. };
  223.  
  224. MODULE void rq(STRPTR message);
  225. MODULE void absolute(void);
  226. MODULE void getea(void);
  227. MODULE void immediate(FLAG bin, TEXT special);
  228. MODULE void skip(void);
  229. MODULE void zero(TEXT special);
  230. MODULE FLAG getcondition(FLAG istrue);
  231. MODULE void binarize(FLAG invert);
  232. MODULE void printlabel(void);
  233. MODULE void dolf(void);
  234. MODULE void prepare(ULONG value);
  235. MODULE void tellwhere(void);
  236.  
  237. IMPORT struct ExecBase*      SysBase;
  238.  
  239. MODULE UBYTE                *Buffer1     = NULL,
  240.                             *Buffer2     = NULL,
  241.                             *Buffer3     = NULL;
  242. MODULE ULONG                 ic, oc,
  243.                              level       = 6,
  244.                              x;
  245. MODULE TEXT                  filename[512 + 1],
  246.                              op[7 + 1],
  247.                              r,
  248.                              where[4];
  249. MODULE FLAG                  ibm         = TRUE;
  250.  
  251. void main(int argc, char** argv)
  252. {   ULONG                 ac, i, hc, size, tc, xx, y, yc;
  253.     BPTR                  TheHandle = NULL;
  254.     FLAG                  addr3,
  255.                           done,
  256.                           found,
  257.                           started;
  258.     SLONG                 args[3]   = {0, 0, 0};
  259.     struct FileInfoBlock* FIBPtr    = NULL;
  260.     struct RDArgs*        ArgsPtr   = NULL;
  261.     TEXT                  bytes;
  262.  
  263.     /* Start of program.
  264.  
  265.     version embedding into executable */
  266.     if (0) /* that is, never */
  267.     {   printf("$VER: Annotate 1.11 (23.12.2003)");
  268.     }
  269.  
  270.     if (SysBase->LibNode.lib_Version < 36L)
  271.     {   rq("Annotate: Need AmigaOS 2.0!");
  272.     }
  273.  
  274.     if (argc) /* started from CLI */
  275.     {   if (!(ArgsPtr = ReadArgs
  276.         (   "FILE/A,LEVEL/N,AMIGA/S", // all compulsory (/A) arguments must be first
  277.             (LONG *) args,
  278.             NULL
  279.         )))
  280.         {   printf
  281.             (   "Usage: %s [LEVEL=<number>] [AMIGA] [FILE=]<filename>\n",
  282.                 argv[0]
  283.             );
  284.             exit(EXIT_FAILURE);
  285.         }
  286.         // assert(args[0]);
  287.         if (strlen(args[0]) > 512)
  288.         {   printf("%s: <filename> must be <= 512 characters!\n", argv[0]);
  289.             FreeArgs(ArgsPtr);
  290.             ArgsPtr = NULL;
  291.             exit(EXIT_FAILURE);
  292.         }
  293.         strcpy(filename, args[0]);
  294.         if (args[1])
  295.         {   level = (ULONG) (*((SLONG *) args[1]));
  296.             if (level < 1 && level > 6)
  297.             {   printf("%s: <number> must be 1-6!\n", argv[0]);
  298.                 FreeArgs(ArgsPtr);
  299.                 ArgsPtr = NULL;
  300.                 exit(EXIT_FAILURE);
  301.         }   }
  302.         if (args[2])
  303.         {   ibm = FALSE;
  304.     }   }
  305.     else // started from WB
  306.     {   printf
  307.         (   "Usage: %s [LEVEL=<number>] [AMIGA] [FILE=]<filename>\n",
  308.             argv[0]
  309.         );
  310.         FreeArgs(ArgsPtr);
  311.         ArgsPtr = NULL;
  312.         exit(EXIT_FAILURE);
  313.     }
  314.     if (ArgsPtr)
  315.     {   FreeArgs(ArgsPtr);
  316.         ArgsPtr = NULL;
  317.     }
  318.  
  319.     // first pass --------------------------------------------------------
  320.  
  321.     if (!(TheHandle = (BPTR) Lock(filename, ACCESS_READ)))
  322.     {   rq("Lock() failed!");
  323.     }
  324.     if (!(FIBPtr = AllocDosObject(DOS_FIB, NULL)))
  325.     {   UnLock(TheHandle);
  326.         TheHandle = NULL;
  327.         rq("AllocDosObject() failed!");
  328.     }
  329.     if (!(Examine(TheHandle, FIBPtr)))
  330.     {   UnLock(TheHandle);
  331.         TheHandle = NULL;
  332.         rq("Examine() failed!");
  333.     }
  334.     UnLock(TheHandle);
  335.     TheHandle = NULL;
  336.     size = FIBPtr->fib_Size;
  337.     if (FIBPtr->fib_DirEntryType != -3)
  338.     {   FreeDosObject(DOS_FIB, FIBPtr);
  339.         FIBPtr = NULL;
  340.         rq("Not a file!");
  341.     }
  342.     FreeDosObject(DOS_FIB, FIBPtr);
  343.     FIBPtr = NULL;
  344.  
  345.     if (!(Buffer1 = AllocVec(size + 1, MEMF_ANY | MEMF_PUBLIC)))
  346.     {   rq("Out of memory!");
  347.     }
  348.     if (!(TheHandle = Open(filename, MODE_OLDFILE)))
  349.     {   rq("Open() failed!");
  350.     }
  351.     if (Read(TheHandle, Buffer1, size + 1) == -1)
  352.     {   Close(TheHandle);
  353.         TheHandle = NULL;
  354.         FreeVec(Buffer1);
  355.         Buffer1 = NULL;
  356.         rq("Read() failed!");
  357.     }
  358.     Close(TheHandle);
  359.     TheHandle = NULL;
  360.     Buffer1[size] = 0;
  361.  
  362.     /* Buffer1 is now allocated and filled. */
  363.  
  364.     if (!(Buffer2 = AllocVec(8192 + (size * 2), MEMF_ANY | MEMF_PUBLIC)))
  365.     {   rq("Out of memory!");
  366.     }
  367.  
  368.     ic = oc = x = y = 0;
  369.     addr3 = FALSE;
  370.     while (ic < size)
  371.     {   if (Buffer1[ic] == TAB)
  372.         {   xx = 8 - (x % 8);
  373.             x += xx;
  374.             for (i = 1; i <= xx; i++)
  375.             {   Buffer2[oc++] = ' ';
  376.             }
  377.             ic++;
  378.         } elif
  379.         (   (Buffer1[ic] == 'X' && Buffer1[ic + 5] != ':')
  380.          || (Buffer1[ic] == 'L' && Buffer1[ic + 1] == '2')
  381.         )
  382.         {   Buffer2[oc]     = '$';             // "$1234"
  383.             Buffer2[oc + 1] = Buffer1[ic + 1]; // "$1234"
  384.             Buffer2[oc + 2] = Buffer1[ic + 2]; // "$1234"
  385.             Buffer2[oc + 3] = Buffer1[ic + 3]; // "$1234"
  386.             Buffer2[oc + 4] = Buffer1[ic + 4]; // "$1234"
  387.             ic += 5;
  388.             oc += 5;
  389.             x += 5;
  390.         } elif (!strncmp(&Buffer1[ic], "00000H", 6))
  391.         {   Buffer2[oc]     = '$';             // "$1234"
  392.             Buffer2[oc + 1] = Buffer1[ic + 1]; // "$1234"
  393.             Buffer2[oc + 2] = Buffer1[ic + 2]; // "$1234"
  394.             Buffer2[oc + 3] = Buffer1[ic + 3]; // "$1234"
  395.             Buffer2[oc + 4] = Buffer1[ic + 4]; // "$1234"
  396.             ic += 6;
  397.             oc += 5;
  398.             x += 5;
  399.         } elif (!strncmp(&Buffer1[ic], "\t\t;INFO: indirect jump", 22))
  400.         {   ic += 22;
  401.         } elif (Buffer1[ic] == '0' && Buffer1[ic + 3] == 'H')
  402.         {   // change "012H" to "$12"
  403.             Buffer2[oc] = '$';
  404.             Buffer2[oc + 1] = Buffer1[ic + 1];
  405.             Buffer2[oc + 2] = Buffer1[ic + 2];
  406.             ic += 4;
  407.             oc += 3;
  408.             x += 3;
  409.         } elif
  410.         (   Buffer1[ic] == ','
  411.          && (   Buffer1[ic + 1] == '+'
  412.              || Buffer1[ic + 1] == '-'
  413.         )   )
  414.         {   ic++;
  415.             Buffer2[oc++] = Buffer1[ic++];
  416.             x++;
  417.         } elif (Buffer1[ic] == CR)
  418.         {   ic++;
  419.         } elif (Buffer1[ic] == LF)
  420.         {   if (addr3)
  421.             {   Buffer2[oc++] = ',';
  422.                 Buffer2[oc++] = 'r';
  423.                 Buffer2[oc++] = '3';
  424.                 addr3 = FALSE;
  425.             }
  426.             Buffer2[oc++] = Buffer1[ic++];
  427.             x = 0;
  428.             y++;
  429.             if (y == 16)
  430.             {   ic += 6;
  431.                 Buffer2[oc] = 0;
  432.  
  433.                 if (level >= 3)
  434.                 {   for (i = 0; i < EQUATESLINES; i++)
  435.                     {   if (level >= 5 || i == 0 || equates[i][0] != ';')
  436.                         {   strcat(Buffer2, equates[i]);
  437.                             dolf();
  438.                 }   }   }
  439.  
  440.                 strcat(Buffer2,
  441. ";2650 Equates-------------------------------------------------------------\n"
  442. "z               equ 0\n"
  443. "eq              equ z\n"
  444. "p               equ 1\n"
  445. "gt              equ p\n"
  446. "n               equ 2\n"
  447. "lt              equ n\n"
  448. "un              equ 3\n"
  449. ";-------------------------------------------------------------------------\n"
  450.                 );
  451.  
  452.                 oc = strlen(Buffer2);
  453.         }   }
  454.         else
  455.         {   if
  456.             (   !strncmp(Buffer1, "bxa",  3)
  457.              || !strncmp(Buffer2, "bsxa", 4)
  458.             )
  459.             {   addr3 = TRUE;
  460.             }
  461.             Buffer2[oc++] = Buffer1[ic++];
  462.             x++;
  463.     }   }
  464.  
  465.     Buffer2[oc] = 0;
  466.     dolf();
  467.     for (i = 0; i <= 7; i++)
  468.     {   Buffer2[oc++] = ' ';
  469.     }
  470.     Buffer2[oc++] = 'e';
  471.     Buffer2[oc++] = 'n';
  472.     Buffer2[oc++] = 'd';
  473.     Buffer2[oc] = 0;
  474.     dolf();
  475.  
  476.     FreeVec(Buffer1);
  477.     Buffer1 = NULL;
  478.  
  479.     // second pass -------------------------------------------------------
  480.  
  481.     size = oc;
  482.     if (!(Buffer3 = AllocVec(size * 12, MEMF_ANY | MEMF_PUBLIC)))
  483.     {   rq("Out of memory!");
  484.     }
  485.  
  486.     ic = oc = 0;
  487.  
  488.     if (level <= 1)
  489.     {   while (ic < size)
  490.         {   if (Buffer2[ic] == LF && ibm)
  491.             {   Buffer3[oc++] = CR;
  492.             }
  493.             Buffer3[oc++] = Buffer2[ic++];
  494.         }
  495.         goto FINISH;
  496.     }
  497.  
  498.     started = FALSE;
  499.     while (ic < size)
  500.     {   tc = ic;
  501.         x = 0;
  502.         ac = oc;
  503.  
  504.         done = FALSE;
  505.         do
  506.         {   if (Buffer2[ic] == LF)
  507.             {   done = TRUE;
  508.                 ic++;
  509.             } elif (Buffer2[ic] == ';' && Buffer2[ic + 1] == '-')
  510.             {   started = TRUE;
  511.                 Buffer3[oc++] = Buffer2[ic++];
  512.                 x++;
  513.             } elif
  514.             (   started
  515.              && level >= 3
  516.              && Buffer2[ic]     == '$'
  517.              && Buffer2[ic + 1] == '1'
  518.              && Buffer2[ic + 5] == LF
  519.             )
  520.             {   found = FALSE;
  521.                 for (i = 0; i < REPLACEMENTS; i++)
  522.                 {   if (!strncmp(replacement[i].old, Buffer2 + ic + 2, 3))
  523.                     {   Buffer3[oc] = 0;
  524.                         strcat(Buffer3, replacement[i].new);
  525.                         ic += 5;
  526.                         oc += strlen(replacement[i].new);
  527.                         x  += strlen(replacement[i].new);
  528.                         found = TRUE;
  529.                         break;
  530.                 }   }
  531.                 if (!found)
  532.                 {   Buffer3[oc++] = Buffer2[ic++];
  533.                     x++;
  534.             }   }
  535.             else
  536.             {   Buffer3[oc++] = Buffer2[ic++];
  537.                 x++;
  538.         }   }
  539.         while (!done);
  540.         hc = ic;
  541.         ic = tc;
  542.  
  543.         skip();
  544.  
  545.         bytes = '0';
  546.         if (level >= 6)
  547.         {   if
  548.             (   !strncmp(&Buffer2[ic], "adda", 4)
  549.              || !strncmp(&Buffer2[ic], "anda", 4)
  550.              || !strncmp(&Buffer2[ic], "bcfa", 4)
  551.              || !strncmp(&Buffer2[ic], "bcta", 4)
  552.              || !strncmp(&Buffer2[ic], "bdra", 4)
  553.              || !strncmp(&Buffer2[ic], "bira", 4)
  554.              || !strncmp(&Buffer2[ic], "brna", 4)
  555.              || !strncmp(&Buffer2[ic], "bsfa", 4)
  556.              || !strncmp(&Buffer2[ic], "bsna", 4)
  557.              || !strncmp(&Buffer2[ic], "bsta", 4)
  558.              || !strncmp(&Buffer2[ic], "bsxa", 4)
  559.              || !strncmp(&Buffer2[ic], "bxa" , 3)
  560.              || !strncmp(&Buffer2[ic], "coma", 4)
  561.              || !strncmp(&Buffer2[ic], "eora", 4)
  562.              || !strncmp(&Buffer2[ic], "iora", 4)
  563.              || !strncmp(&Buffer2[ic], "loda", 4)
  564.              || !strncmp(&Buffer2[ic], "stra", 4)
  565.              || !strncmp(&Buffer2[ic], "suba", 4)
  566.             )
  567.             {   bytes = '3';
  568.             } elif
  569.             (   !strncmp(&Buffer2[ic], "addi", 4)
  570.              || !strncmp(&Buffer2[ic], "addr", 4)
  571.              || !strncmp(&Buffer2[ic], "andi", 4)
  572.              || !strncmp(&Buffer2[ic], "andr", 4)
  573.              || !strncmp(&Buffer2[ic], "bcfr", 4)
  574.              || !strncmp(&Buffer2[ic], "bctr", 4)
  575.              || !strncmp(&Buffer2[ic], "bdrr", 4)
  576.              || !strncmp(&Buffer2[ic], "birr", 4)
  577.              || !strncmp(&Buffer2[ic], "brnr", 4)
  578.              || !strncmp(&Buffer2[ic], "bsfr", 4)
  579.              || !strncmp(&Buffer2[ic], "bsnr", 4)
  580.              || !strncmp(&Buffer2[ic], "bstr", 4)
  581.              || !strncmp(&Buffer2[ic], "comi", 4)
  582.              || !strncmp(&Buffer2[ic], "comr", 4)
  583.              || !strncmp(&Buffer2[ic], "cpsl", 4)
  584.              || !strncmp(&Buffer2[ic], "cpsu", 4)
  585.              || !strncmp(&Buffer2[ic], "eori", 4)
  586.              || !strncmp(&Buffer2[ic], "eorr", 4)
  587.              || !strncmp(&Buffer2[ic], "iori", 4)
  588.              || !strncmp(&Buffer2[ic], "iorr", 4)
  589.              || !strncmp(&Buffer2[ic], "lodi", 4)
  590.              || !strncmp(&Buffer2[ic], "lodr", 4)
  591.              || !strncmp(&Buffer2[ic], "lpsl", 4)
  592.              || !strncmp(&Buffer2[ic], "lpsu", 4)
  593.              || !strncmp(&Buffer2[ic], "ppsl", 4)
  594.              || !strncmp(&Buffer2[ic], "ppsu", 4)
  595.              || !strncmp(&Buffer2[ic], "rede", 4) // not further supported
  596.              || !strncmp(&Buffer2[ic], "spsl", 4)
  597.              || !strncmp(&Buffer2[ic], "spsu", 4)
  598.              || !strncmp(&Buffer2[ic], "strr", 4)
  599.              || !strncmp(&Buffer2[ic], "subi", 4)
  600.              || !strncmp(&Buffer2[ic], "subr", 4)
  601.              || !strncmp(&Buffer2[ic], "tmi" , 3)
  602.              || !strncmp(&Buffer2[ic], "tpsl", 4)
  603.              || !strncmp(&Buffer2[ic], "tpsu", 4)
  604.              || !strncmp(&Buffer2[ic], "zbrr", 4)
  605.              || !strncmp(&Buffer2[ic], "zbsr", 4)
  606.              || !strncmp(&Buffer2[ic], "wrte", 4) // not further supported
  607.             )
  608.             {   bytes = '2';
  609.             } elif
  610.             (   !strncmp(&Buffer2[ic], "addz", 4)
  611.              || !strncmp(&Buffer2[ic], "andz", 4)
  612.              || !strncmp(&Buffer2[ic], "comz", 4)
  613.              || !strncmp(&Buffer2[ic], "dar" , 3)
  614.              || !strncmp(&Buffer2[ic], "eorz", 4)
  615.              || !strncmp(&Buffer2[ic], "halt", 4) // not further supported
  616.              || !strncmp(&Buffer2[ic], "iorz", 4)
  617.              || !strncmp(&Buffer2[ic], "lodz", 4)
  618.              || !strncmp(&Buffer2[ic], "nop" , 3)
  619.              || !strncmp(&Buffer2[ic], "redc", 4) // not further supported
  620.              || !strncmp(&Buffer2[ic], "redd", 4) // not further supported
  621.              || !strncmp(&Buffer2[ic], "retc", 4)
  622.              || !strncmp(&Buffer2[ic], "rete", 4) // not further supported
  623.              || !strncmp(&Buffer2[ic], "rrl" , 3)
  624.              || !strncmp(&Buffer2[ic], "rrr" , 3)
  625.              || !strncmp(&Buffer2[ic], "strz", 4)
  626.              || !strncmp(&Buffer2[ic], "subz", 4)
  627.              || !strncmp(&Buffer2[ic], "wrtc", 4) // not further supported
  628.              || !strncmp(&Buffer2[ic], "wrtd", 4) // not further supported
  629.             )
  630.             {   bytes = '1';
  631.         }   }
  632.  
  633.         if
  634.         (   !strncmp(&Buffer2[ic], "anda", 4)
  635.          || !strncmp(&Buffer2[ic], "andr", 4)
  636.         )
  637.         {   prepare(4);
  638.             strcpy(op, "&=");
  639.             absolute();
  640.         } elif (!strncmp(&Buffer2[ic], "andi", 4))
  641.         {   prepare(4);
  642.             strcpy(op, "&=");
  643.             immediate(TRUE, 'A');
  644.         } elif (!strncmp(&Buffer2[ic], "andz", 4))
  645.         {   prepare(4);
  646.             strcpy(op, "&=");
  647.             zero('A');
  648.         } elif
  649.         (   !strncmp(&Buffer2[ic], "adda", 4)
  650.          || !strncmp(&Buffer2[ic], "addr", 4)
  651.         )
  652.         {   prepare(4);
  653.             strcpy(op, "+=");
  654.             absolute();
  655.         } elif (!strncmp(&Buffer2[ic], "addi", 4))
  656.         {   prepare(4);
  657.             strcpy(op, "+=");
  658.             immediate(FALSE, 'D');
  659.         } elif (!strncmp(&Buffer2[ic], "addz", 4))
  660.         {   prepare(4);
  661.             strcpy(op, "+=");
  662.             zero('D');
  663.         } elif
  664.         (   !strncmp(&Buffer2[ic], "bcfa", 4)
  665.          || !strncmp(&Buffer2[ic], "bcfr", 4)
  666.         )
  667.         {   prepare(4);
  668.             getcondition(FALSE);
  669.             strcat(Buffer3, "if ");
  670.             strcat(Buffer3, op);
  671.             strcat(Buffer3, " goto ");
  672.             printlabel();
  673.             Buffer3[oc++] = ';';
  674.         } elif
  675.         (   !strncmp(&Buffer2[ic], "bcta", 4)
  676.          || !strncmp(&Buffer2[ic], "bctr", 4)
  677.         )
  678.         {   prepare(4);
  679.             if (getcondition(TRUE))
  680.             {   strcat(Buffer3, "if ");
  681.                 strcat(Buffer3, op);
  682.                 strcat(Buffer3, " ");
  683.             }
  684.             strcat(Buffer3, "goto ");
  685.             printlabel();
  686.             Buffer3[oc++] = ';';
  687.         } elif
  688.         (   !strncmp(&Buffer2[ic], "bdra", 4)
  689.          || !strncmp(&Buffer2[ic], "bdrr", 4)
  690.         )
  691.         {   prepare(4);
  692.             skip();
  693.             ic++;
  694.             r = Buffer2[ic++];
  695.             skip();
  696.             Buffer3[oc] = 0;
  697.             strcat(Buffer3, "if (--r");
  698.             oc += 7;
  699.             Buffer3[oc++] = r;
  700.             Buffer3[oc] = 0;
  701.             strcat(Buffer3, " != 0) goto ");
  702.             printlabel();
  703.             Buffer3[oc++] = ';';
  704.         } elif
  705.         (   !strncmp(&Buffer2[ic], "bira", 4)
  706.          || !strncmp(&Buffer2[ic], "birr", 4)
  707.         )
  708.         {   prepare(4);
  709.             skip();
  710.             ic++;
  711.             r = Buffer2[ic++];
  712.             skip();
  713.             Buffer3[oc] = 0;
  714.             strcat(Buffer3, "if (++r");
  715.             oc += 7;
  716.             Buffer3[oc++] = r;
  717.             strcat(Buffer3, " != 0) goto ");
  718.             printlabel();
  719.             Buffer3[oc++] = ';';
  720.         } elif
  721.         (   !strncmp(&Buffer2[ic], "brna", 4)
  722.          || !strncmp(&Buffer2[ic], "brnr", 4)
  723.         )
  724.         {   prepare(4);
  725.             skip();
  726.             ic++;
  727.             r = Buffer2[ic++];
  728.             skip();
  729.             Buffer3[oc] = 0;
  730.             strcat(Buffer3, "if (r");
  731.             oc += 5;
  732.             Buffer3[oc++] = r;
  733.             strcat(Buffer3, " != 0) goto ");
  734.             printlabel();
  735.             Buffer3[oc++] = ';';
  736.         } elif
  737.         (   !strncmp(&Buffer2[ic], "bsna", 4)
  738.          || !strncmp(&Buffer2[ic], "bsnr", 4)
  739.         )
  740.         {   prepare(4);
  741.             skip();
  742.             ic++;
  743.             r = Buffer2[ic++];
  744.             skip();
  745.             Buffer3[oc] = 0;
  746.             strcat(Buffer3, "if (r");
  747.             oc += 5;
  748.             Buffer3[oc++] = r;
  749.             strcat(Buffer3, " != 0) goto ");
  750.             printlabel();
  751.             Buffer3[oc++] = ';';
  752.         } elif
  753.         (   !strncmp(&Buffer2[ic], "bsfa", 4)
  754.          || !strncmp(&Buffer2[ic], "bsfr", 4)
  755.         )
  756.         {   prepare(4);
  757.             getcondition(FALSE);
  758.             strcat(Buffer3, "if ");
  759.             strcat(Buffer3, op);
  760.             strcat(Buffer3, " gosub ");
  761.             printlabel();
  762.             Buffer3[oc++] = ';';
  763.         } elif
  764.         (   !strncmp(&Buffer2[ic], "bsta", 4)
  765.          || !strncmp(&Buffer2[ic], "bstr", 4)
  766.         )
  767.         {   prepare(4);
  768.             if (getcondition(TRUE))
  769.             {   strcat(Buffer3, "if ");
  770.                 strcat(Buffer3, op);
  771.                 strcat(Buffer3, " ");
  772.             }
  773.             strcat(Buffer3, "gosub ");
  774.             printlabel();
  775.             Buffer3[oc++] = ';';
  776.         } elif (!strncmp(&Buffer2[ic], "bsxa", 4))
  777.         {   prepare(4);
  778.             Buffer3[oc] = 0;
  779.             strcat(Buffer3, "gosub ");
  780.             printlabel();
  781.             strcat(Buffer3, " + r3;");
  782.             oc += 6;
  783.         } elif (!strncmp(&Buffer2[ic], "bxa",  3))
  784.         {   prepare(3);
  785.             Buffer3[oc] = 0;
  786.             strcat(Buffer3, "goto ");
  787.             printlabel();
  788.             strcat(Buffer3, " + r3;");
  789.             oc += 6;
  790.         } elif
  791.         (   !strncmp(&Buffer2[ic], "coma", 4)
  792.          || !strncmp(&Buffer2[ic], "comr", 4)
  793.         )
  794.         {   prepare(4);
  795.             Buffer3[oc] = 0;
  796.             strcat(Buffer3, "compare ");
  797.             oc += 8;
  798.             strcpy(op, "against");
  799.             absolute();
  800.         } elif (!strncmp(&Buffer2[ic], "comi", 4))
  801.         {   prepare(4);
  802.             Buffer3[oc] = 0;
  803.             strcat(Buffer3, "compare ");
  804.             oc += 8;
  805.             strcpy(op, "against");
  806.             immediate(FALSE, 'C');
  807.         } elif (!strncmp(&Buffer2[ic], "comz", 4))
  808.         {   prepare(4);
  809.             Buffer3[oc] = 0;
  810.             strcat(Buffer3, "compare ");
  811.             oc += 8;
  812.             strcpy(op, "against");
  813.             zero('C');
  814.         } elif (!strncmp(&Buffer2[ic], "cpsl", 4))
  815.         {   prepare(4);
  816.             skip();
  817.             Buffer3[oc] = 0;
  818.             strcat(Buffer3, "PSL &= ");
  819.             oc += 7;
  820.             binarize(TRUE);
  821.             Buffer3[oc++] = ';';
  822.         } elif (!strncmp(&Buffer2[ic], "cpsu", 4))
  823.         {   prepare(4);
  824.             skip();
  825.             Buffer3[oc] = 0;
  826.             strcat(Buffer3, "PSU &= ");
  827.             oc += 7;
  828.             binarize(TRUE);
  829.             Buffer3[oc++] = ';';
  830.         } elif (!strncmp(&Buffer2[ic], "dar", 3))
  831.         {   prepare(3);
  832.             skip();
  833.             ic++;
  834.             r = Buffer2[ic++];
  835.             Buffer3[oc++] = 'r';
  836.             Buffer3[oc++] = r;
  837.             Buffer3[oc] = 0;
  838.             strcat(Buffer3, " = BCD(r");
  839.             oc += 8;
  840.             Buffer3[oc++] = r;
  841.             Buffer3[oc++] = ')';
  842.             Buffer3[oc++] = ';';
  843.         } elif
  844.         (   !strncmp(&Buffer2[ic], "eora", 4)
  845.          || !strncmp(&Buffer2[ic], "eorr", 4)
  846.         )
  847.         {   prepare(4);
  848.             strcpy(op, "^=");
  849.             absolute();
  850.         } elif (!strncmp(&Buffer2[ic], "eori", 4))
  851.         {   prepare(4);
  852.             strcpy(op, "^=");
  853.             immediate(TRUE, 'E');
  854.         } elif (!strncmp(&Buffer2[ic], "eorz", 4))
  855.         {   prepare(4);
  856.             strcpy(op, "^=");
  857.             zero('E');
  858.         } elif
  859.         (   !strncmp(&Buffer2[ic], "iora", 4)
  860.          || !strncmp(&Buffer2[ic], "iorr", 4)
  861.         )
  862.         {   prepare(4);
  863.             strcpy(op, "|=");
  864.             absolute();
  865.         } elif (!strncmp(&Buffer2[ic], "iori", 4))
  866.         {   prepare(4);
  867.             strcpy(op, "|=");
  868.             immediate(TRUE, 'I');
  869.         } elif (!strncmp(&Buffer2[ic], "iorz", 4))
  870.         {   prepare(4);
  871.             strcpy(op, "|=");
  872.             zero('I');
  873.         } elif
  874.         (   !strncmp(&Buffer2[ic], "loda", 4)
  875.          || !strncmp(&Buffer2[ic], "lodr", 4)
  876.         )
  877.         {   prepare(4);
  878.             strcpy(op, "=");
  879.             absolute();
  880.         } elif (!strncmp(&Buffer2[ic], "lodi", 4))
  881.         {   prepare(4);
  882.             strcpy(op, "=");
  883.             immediate(FALSE, 'L');
  884.         } elif (!strncmp(&Buffer2[ic], "lodz", 4))
  885.         {   prepare(4);
  886.             strcpy(op, "=");
  887.             zero('L');
  888.         } elif (!strncmp(&Buffer2[ic], "lpsl", 4))
  889.         {   prepare(4);
  890.             Buffer3[oc] = 0;
  891.             strcat(Buffer3, "PSL = r0;");
  892.             oc += 9;
  893.         } elif (!strncmp(&Buffer2[ic], "lpsu", 4))
  894.         {   prepare(4);
  895.             Buffer3[oc] = 0;
  896.             strcat(Buffer3, "PSU = r0;");
  897.             oc += 9;
  898.         } elif (!strncmp(&Buffer2[ic], "nop", 3))
  899.         {   prepare(3);
  900.         } elif (!strncmp(&Buffer2[ic], "ppsl", 4))
  901.         {   prepare(4);
  902.             skip();
  903.             Buffer3[oc] = 0;
  904.             strcat(Buffer3, "PSL |= ");
  905.             oc += 7;
  906.             binarize(FALSE);
  907.             Buffer3[oc++] = ';';
  908.         } elif (!strncmp(&Buffer2[ic], "ppsu", 4))
  909.         {   prepare(4);
  910.             skip();
  911.             Buffer3[oc] = 0;
  912.             strcat(Buffer3, "PSU |= ");
  913.             oc += 7;
  914.             binarize(FALSE);
  915.             Buffer3[oc++] = ';';
  916.         } elif (!strncmp(&Buffer2[ic], "retc", 4))
  917.         {   prepare(4);
  918.             skip();
  919.             if (getcondition(TRUE))
  920.             {   strcat(Buffer3, "if ");
  921.                 strcat(Buffer3, op);
  922.                 strcat(Buffer3, " ");
  923.             }
  924.             strcat(Buffer3, "return;");
  925.             oc += 7;
  926.         } elif (!strncmp(&Buffer2[ic], "rrl", 3))
  927.         {   prepare(3);
  928.             skip();
  929.             ic++;
  930.             r = Buffer2[ic++];
  931.             Buffer3[oc++] = 'r';
  932.             Buffer3[oc++] = r;
  933.             Buffer3[oc] = 0;
  934.             strcat(Buffer3, " <<= 1;");
  935.             oc += 7;
  936.         } elif (!strncmp(&Buffer2[ic], "rrr", 3))
  937.         {   prepare(3);
  938.             skip();
  939.             ic++;
  940.             r = Buffer2[ic++];
  941.             Buffer3[oc++] = 'r';
  942.             Buffer3[oc++] = r;
  943.             Buffer3[oc] = 0;
  944.             strcat(Buffer3, " >>= 1;");
  945.             oc += 7;
  946.         } elif (!strncmp(&Buffer2[ic], "spsl", 4))
  947.         {   prepare(4);
  948.             Buffer3[oc] = 0;
  949.             strcat(Buffer3, "r0 = PSL;");
  950.             oc += 9;
  951.         } elif (!strncmp(&Buffer2[ic], "spsu", 4))
  952.         {   prepare(4);
  953.             Buffer3[oc] = 0;
  954.             strcat(Buffer3, "r0 = PSU;");
  955.             oc += 9;
  956.         } elif
  957.         (   !strncmp(&Buffer2[ic], "stra", 4)
  958.          || !strncmp(&Buffer2[ic], "strr", 4)
  959.         )
  960.         {   prepare(4);
  961.             skip();
  962.             ic++;
  963.             r = Buffer2[ic++];
  964.             skip();
  965.             getea();
  966.             Buffer3[oc++] = ' ';
  967.             Buffer3[oc++] = '=';
  968.             Buffer3[oc++] = ' ';
  969.             Buffer3[oc++] = 'r';
  970.             Buffer3[oc++] = r;
  971.             Buffer3[oc++] = ';';
  972.             tellwhere();
  973.         } elif (!strncmp(&Buffer2[ic], "strz", 4))
  974.         {   prepare(4);
  975.             skip();
  976.             ic++;
  977.             r = Buffer2[ic++];
  978.             skip();
  979.             Buffer3[oc++] = 'r';
  980.             Buffer3[oc++] = r;
  981.             Buffer3[oc++] = ' ';
  982.             Buffer3[oc++] = '=';
  983.             Buffer3[oc++] = ' ';
  984.             Buffer3[oc++] = 'r';
  985.             Buffer3[oc++] = '0';
  986.             Buffer3[oc++] = ';';
  987.         } elif
  988.         (   !strncmp(&Buffer2[ic], "suba", 4)
  989.          || !strncmp(&Buffer2[ic], "subr", 4)
  990.         )
  991.         {   prepare(4);
  992.             strcpy(op, "-=");
  993.             absolute();
  994.         } elif (!strncmp(&Buffer2[ic], "subi", 4))
  995.         {   prepare(4);
  996.             strcpy(op, "-=");
  997.             immediate(FALSE, 'S');
  998.         } elif (!strncmp(&Buffer2[ic], "subz", 4))
  999.         {   prepare(4);
  1000.             strcpy(op, "-=");
  1001.             zero('S');
  1002.         } elif (!strncmp(&Buffer2[ic], "tmi",  3))
  1003.         {   prepare(3);
  1004.             skip();
  1005.             ic++;
  1006.             r = Buffer2[ic];
  1007.             ic++;
  1008.             skip();
  1009.             Buffer3[oc] = 0;
  1010.             strcat(Buffer3, "test bits ");
  1011.             oc += 10;
  1012.             binarize(FALSE);
  1013.             Buffer3[oc] = 0;
  1014.             strcat(Buffer3, " of r");
  1015.             oc += 5;
  1016.             Buffer3[oc++] = r;
  1017.             Buffer3[oc++] = ';';
  1018.         } elif (!strncmp(&Buffer2[ic], "tpsl", 4))
  1019.         {   prepare(4);
  1020.             skip();
  1021.             Buffer3[oc] = 0;
  1022.             strcat(Buffer3, "test bits ");
  1023.             oc += 10;
  1024.             binarize(FALSE);
  1025.             Buffer3[oc] = 0;
  1026.             strcat(Buffer3, " of PSL");
  1027.             oc += 7;
  1028.             Buffer3[oc++] = ';';
  1029.         } elif (!strncmp(&Buffer2[ic], "tpsu", 4))
  1030.         {   prepare(4);
  1031.             skip();
  1032.             Buffer3[oc] = 0;
  1033.             strcat(Buffer3, "test bits ");
  1034.             oc += 10;
  1035.             binarize(FALSE);
  1036.             Buffer3[oc] = 0;
  1037.             strcat(Buffer3, " of PSU");
  1038.             oc += 7;
  1039.             Buffer3[oc++] = ';';
  1040.         } elif (!strncmp(&Buffer2[ic], "zbrr", 4))
  1041.         {   prepare(4);
  1042.             skip();
  1043.             Buffer3[oc] = 0;
  1044.             strcat(Buffer3, "goto ");
  1045.             oc += 5;
  1046.             printlabel();
  1047.             Buffer3[oc++] = ';';
  1048.         } elif (!strncmp(&Buffer2[ic], "zbsr", 4))
  1049.         {   prepare(4);
  1050.             skip();
  1051.             Buffer3[oc] = 0;
  1052.             strcat(Buffer3, "gosub ");
  1053.             oc += 6;
  1054.             printlabel();
  1055.             Buffer3[oc++] = ';';
  1056.         }
  1057.  
  1058.         ic = hc;
  1059.         if (level >= 6 && bytes != '0')
  1060.         {   yc = oc - ac;
  1061.             if (yc >= 73)
  1062.             {   if (ibm)
  1063.                 {   Buffer3[oc++] = CR;
  1064.                 }
  1065.                 Buffer3[oc++] = LF;
  1066.                 yc = 0;
  1067.             }
  1068.             for (i = yc + 1; i < 73; i++)
  1069.             {   Buffer3[oc++] = ' ';
  1070.             }
  1071.             Buffer3[oc++] = ';';
  1072.             Buffer3[oc++] = bytes;
  1073.         }
  1074.  
  1075.         if (ibm)
  1076.         {   Buffer3[oc++] = CR;
  1077.         }
  1078.         Buffer3[oc++] = LF;
  1079.     }
  1080.  
  1081. FINISH:
  1082.     Buffer3[oc] = 0;
  1083.  
  1084.     FreeVec(Buffer2);
  1085.     Buffer2 = NULL;
  1086.  
  1087.     printf("%s", Buffer3);
  1088.     /* This only works with printf(), *not* Printf(). I would not have
  1089.        believed this if I had not seen it for myself. :-) */
  1090.  
  1091.     FreeVec(Buffer3);
  1092.     Buffer3 = NULL;
  1093.  
  1094.     exit(EXIT_SUCCESS); // end of the program. go back to DOS
  1095. }
  1096.  
  1097. MODULE void immediate(FLAG bin, TEXT special)
  1098. {   ULONG i;
  1099.  
  1100.     skip();
  1101.     ic++;
  1102.     r = Buffer2[ic++];
  1103.     skip();
  1104.     Buffer3[oc++] = 'r';
  1105.     Buffer3[oc++] = r;
  1106.  
  1107.     if (special == 'D' && Buffer2[ic + 1] == '0' && Buffer2[ic + 2] == '1')
  1108.     {   Buffer3[oc++] = '+';
  1109.         Buffer3[oc++] = '+';
  1110.     } elif
  1111.     (   (special == 'D' && Buffer2[ic + 1] == 'F' && Buffer2[ic + 2] == 'F')
  1112.      || (special == 'S' && Buffer2[ic + 1] == '0' && Buffer2[ic + 2] == '1')
  1113.     )
  1114.     {   Buffer3[oc++] = '-';
  1115.         Buffer3[oc++] = '-';
  1116.     } else
  1117.     {   Buffer3[oc++] = ' ';
  1118.         Buffer3[oc] = 0;
  1119.         strcat(Buffer3, op);
  1120.         oc = strlen(Buffer3);
  1121.         Buffer3[oc++] = ' ';
  1122.         if (bin)
  1123.         {   binarize(FALSE);
  1124.         } else
  1125.         {   for (i = 0; i <= 2; i++)
  1126.             {   Buffer3[oc++] = Buffer2[ic++];
  1127.     }   }   }
  1128.  
  1129.     Buffer3[oc++] = ';';
  1130. }
  1131. MODULE void skip(void)
  1132. {   while (Buffer2[ic] == ' ' || Buffer2[ic] == ',' || Buffer2[ic] == TAB)
  1133.     {   ic++;
  1134. }   }
  1135. MODULE void absolute(void)
  1136. {   skip();
  1137.     ic++;
  1138.     r = Buffer2[ic++];
  1139.     skip();
  1140.     Buffer3[oc++] = 'r';
  1141.     Buffer3[oc++] = r;
  1142.     Buffer3[oc++] = ' ';
  1143.     Buffer3[oc] = 0;
  1144.     strcat(Buffer3, op);
  1145.     oc = strlen(Buffer3);
  1146.     Buffer3[oc++] = ' ';
  1147.     getea();
  1148.     Buffer3[oc++] = ';';
  1149.     tellwhere();
  1150. }
  1151. MODULE FLAG getcondition(FLAG istrue)
  1152. {   Buffer3[oc] = 0;
  1153.     skip();
  1154.     if (!strncmp(&Buffer2[ic], "un", 2))
  1155.     {   ic += 2;
  1156.         skip();
  1157.         return(FALSE);
  1158.     } elif (!strncmp(&Buffer2[ic], "eq", 2))
  1159.     {   if (istrue)
  1160.         {   strcpy(op, "==");
  1161.         } else
  1162.         {   strcpy(op, "!=");
  1163.         }
  1164.         ic += 2;
  1165.         skip();
  1166.     return(TRUE);
  1167.     } elif (!strncmp(&Buffer2[ic], "gt", 2))
  1168.     {   if (istrue)
  1169.     {   strcpy(op, ">");
  1170.         } else
  1171.         {   strcpy(op, "<=");
  1172.         }
  1173.         ic += 2;
  1174.         skip();
  1175.         return(TRUE);
  1176.     } elif (!strncmp(&Buffer2[ic], "lt", 2))
  1177.     {   if (istrue)
  1178.         {   strcpy(op, "<");
  1179.         } else
  1180.         {   strcpy(op, ">=");
  1181.         }
  1182.         ic += 2;
  1183.         skip();
  1184.         return(TRUE);
  1185.     } else
  1186.     {   ; // there is a problem
  1187.     return(FALSE);
  1188. }   }
  1189. MODULE void zero(TEXT special)
  1190. {   skip();
  1191.     ic++;
  1192.     r = Buffer2[ic++];
  1193.     skip();
  1194.     Buffer3[oc++] = 'r';
  1195.     Buffer3[oc++] = '0';
  1196.     Buffer3[oc++] = ' ';
  1197.  
  1198.     if ((special == 'E' || special == 'S') && r == '0')
  1199.     {   Buffer3[oc++] = '=';
  1200.         Buffer3[oc++] = ' ';
  1201.         Buffer3[oc++] = '0';
  1202.     } elif (special == 'D' && r == '0')
  1203.     {   Buffer3[oc++] = '*';
  1204.         Buffer3[oc++] = '=';
  1205.         Buffer3[oc++] = ' ';
  1206.         Buffer3[oc++] = '2';
  1207.     } else
  1208.     {   Buffer3[oc] = 0;
  1209.         strcat(Buffer3, op);
  1210.         oc = strlen(Buffer3);
  1211.         Buffer3[oc++] = ' ';
  1212.        Buffer3[oc++] = 'r';
  1213.         Buffer3[oc++] = r;
  1214.     }
  1215.     Buffer3[oc++] = ';';
  1216. }
  1217. MODULE void getea(void)
  1218. {   FLAG  done, indirect;
  1219.     ULONG i;
  1220.  
  1221. /* ic is assumed to be pointing to the start of the operand field.
  1222.    oc is assumed to be pointing past the expression, eg. "&=". */
  1223.  
  1224.     if (Buffer2[ic] == '*')
  1225.     {   Buffer3[oc++] = '*';
  1226.     Buffer3[oc++] = '(';
  1227.     indirect = TRUE;
  1228.         ic++;
  1229.     } else
  1230.     {   indirect = FALSE;
  1231.     }
  1232.  
  1233.     done = FALSE;
  1234.     where[0] = 0;
  1235.     if (level >= 3 && Buffer2[ic + 5] == LF)
  1236.     {   for (i = 0; i < REPLACEMENTS; i++)
  1237.         {   if (!strncmp(replacement[i].old, Buffer2 + ic + 2, 3))
  1238.             {   Buffer3[oc] = 0;
  1239.                 strcat(Buffer3, replacement[i].new);
  1240.                 if (level >= 4)
  1241.                 {   where[0] = Buffer2[ic + 1];
  1242.                     where[1] = Buffer2[ic + 2];
  1243.                     where[2] = Buffer2[ic + 3];
  1244.                     where[3] = Buffer2[ic + 4];
  1245.                 }
  1246.                 ic += 5;
  1247.                 oc += strlen(replacement[i].new);
  1248.                 done = TRUE;
  1249.                 break;
  1250.     }   }   }
  1251.  
  1252.     if (!done)
  1253.     {   Buffer3[oc++] = '*';
  1254.         Buffer3[oc++] = '(';
  1255.         Buffer3[oc++] = '$';
  1256.         ic++;
  1257.         if (level >= 4 && Buffer2[ic + 4] == LF)
  1258.         {   for (i = 0; i <= 3; i++)
  1259.             {   where[i] = Buffer2[ic + i];
  1260.         }   }
  1261.         for (i = 0; i <= 3; i++)
  1262.         {   Buffer3[oc++] = Buffer2[ic++];
  1263.     }   }
  1264.     if (indirect)
  1265.     {   Buffer3[oc++] = ')';
  1266.     }
  1267.     if (Buffer2[ic] == ',')
  1268.     {   Buffer3[oc++] = ' ';
  1269.     Buffer3[oc++] = '+';
  1270.     Buffer3[oc++] = ' ';
  1271.     if (Buffer2[ic + 3] == '+')
  1272.     {   Buffer3[oc++] = '+';
  1273.         Buffer3[oc++] = '+';
  1274.     } elif (Buffer2[ic + 3] == '-')
  1275.     {   Buffer3[oc++] = '-';
  1276.         Buffer3[oc++] = '-';
  1277.         }
  1278.         ic++;
  1279.     Buffer3[oc++] = Buffer2[ic++];
  1280.     Buffer3[oc++] = Buffer2[ic++];
  1281.     }
  1282.     if (!done)
  1283.     {   Buffer3[oc++] = ')';
  1284. }   }
  1285. MODULE void binarize(FLAG invert)
  1286. {   UBYTE c0, c1, i, value;
  1287.  
  1288.     ic++; // pass '$'
  1289.     if (Buffer2[ic] >= '0' && Buffer2[ic] <= '9')
  1290.     {   value = Buffer2[ic] - '0';
  1291.     } elif (Buffer2[ic] >= 'A' && Buffer2[ic] <= 'F')
  1292.     {   value = Buffer2[ic] - 'A' + 10;
  1293.     } else value = 0;
  1294.     value *= 16;
  1295.     ic++;
  1296.     if (Buffer2[ic] >= '0' && Buffer2[ic] <= '9')
  1297.     {   value += Buffer2[ic] - '0';
  1298.     } elif (toupper(Buffer2[ic]) >= 'A' && toupper(Buffer2[ic]) <= 'F')
  1299.     {   value += Buffer2[ic] - 'A' + 10;
  1300.     } else value = 0;
  1301.  
  1302.     if (invert)
  1303.     {   c0 = '1';
  1304.         c1 = '0';
  1305.     } else
  1306.     {   c0 = '0';
  1307.         c1 = '1';
  1308.     }
  1309.  
  1310.     // write out binary value
  1311.     Buffer3[oc++] = '%';
  1312.     for (i = 128; i >= 1; i /= 2)
  1313.     {   if (value >= i)
  1314.         {   Buffer3[oc++] = c1;
  1315.             value -= i;
  1316.         } else Buffer3[oc++] = c0;
  1317.     }
  1318. }
  1319. MODULE void rq(STRPTR message)
  1320. {   printf("%s\n", message);
  1321.     exit(EXIT_FAILURE);
  1322. }
  1323. MODULE void printlabel(void)
  1324. {   ULONG i;
  1325.  
  1326.     // Buffer3[] is assumed to be NULL-terminated at this point
  1327.  
  1328.     if (Buffer2[ic] == '*')
  1329.     {   strcat(Buffer3, "*(");
  1330.         ic++;
  1331.     }
  1332.     oc = strlen(Buffer3);
  1333.     for (i = 0; i <= 4; i++)
  1334.     {   Buffer3[oc++] = Buffer2[ic++];
  1335.     }
  1336.     if (Buffer2[ic - 6] == '*')
  1337.     {   Buffer3[oc++] = ')';
  1338.     }
  1339.     Buffer3[oc] = 0;
  1340. }
  1341. MODULE void dolf(void)
  1342. {   oc = strlen(Buffer2);
  1343.     Buffer2[oc++] = LF;
  1344.     Buffer2[oc] = 0;
  1345. }
  1346. MODULE void prepare(ULONG value)
  1347. {   ULONG i;
  1348.  
  1349.     if (x <= 28)
  1350.     {   for (i = x + 1; i < 30; i++)
  1351.         {   Buffer3[oc++] = ' ';
  1352.     }   }
  1353.     else
  1354.     {   if (ibm)
  1355.         {   Buffer3[oc++] = CR;
  1356.         }
  1357.         Buffer3[oc++] = LF;
  1358.         for (i = 1; i < 30; i++)
  1359.         {   Buffer3[oc++] = ' ';
  1360.     }   }
  1361.  
  1362.     Buffer3[oc++] = ';';
  1363.     ic += value;
  1364. }
  1365.  
  1366. MODULE void tellwhere(void)
  1367. {   ULONG i, totalvalue, value[4];
  1368.  
  1369.     if (level >= 4 && where[0])
  1370.     {    for (i = 0; i <= 3; i++)
  1371.          {   if (where[i] >= '0' && where[i] <= '9')
  1372.              {   value[i] = where[i] - '0';
  1373.              } else
  1374.              {   value[i] = where[i] - 'A' + 10;
  1375.          }   }
  1376.          totalvalue = (value[0] * 4096)
  1377.                     + (value[1] *  256)
  1378.                     + (value[2] *   16)
  1379.                     +  value[3];
  1380.  
  1381.          for (i = 0; i < MEMMAPLINES - 1; i++)
  1382.          {   if (totalvalue >= memmap[i].address && totalvalue < memmap[i + 1].address)
  1383.              {    Buffer3[oc++] = ' ';
  1384.                   Buffer3[oc++] = '/';
  1385.                   Buffer3[oc++] = '/';
  1386.                   Buffer3[oc++] = ' ';
  1387.                   Buffer3[oc]   = 0;
  1388.                   strcat(Buffer3, memmap[i].description);
  1389.                   oc += strlen(memmap[i].description);
  1390.                   return;
  1391. }   }    }   }
  1392.